package com.minglead.crawler.schedule;

import com.minglead.crawler.enums.CrawlerMediaEnum;
import com.minglead.crawler.service.impl.YqModelAnalysisTaskImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.time.LocalTime;
import java.util.Date;

/**
 * @description: 爬虫录入定时任务
 * @author: tzf
 * @date: 2024-10-16
 **/
@Configuration
@EnableScheduling
@ConditionalOnProperty(name = "scheduling.enabled", havingValue = "true", matchIfMissing = true)
public class YqCrawlerEnterTask implements SchedulingConfigurer {

    @Autowired
    private YqModelAnalysisTaskImpl yqModelAnalysisTaskImpl;

    //初始化启动时间戳
    private final long startTime = System.currentTimeMillis();
    //初始化耗时时间 1分钟
    private final int consumeTime = 60000;
    //缓冲时间2分钟
    private final long DelayTime = 120000;

    // 记录上次任务完成的时间戳
    private long financeSinaCompTime = startTime;
    private long cbotCompTime = startTime;
    private long ineDailyCompTime = startTime;
    private long gdNationalCompTime = startTime;
    private long gdQuarterCompTime = startTime;
    private long gdSituationCompTime = startTime;
    private long gdAddCompTime = startTime;
    private long gdProductionCompTime = startTime;
    private long gdIndustryCompTime = startTime;
    private long gdTotalCompTime = startTime;

    // 录入任务耗时
    private long financeSinaConsumeTime = consumeTime;
    private long cbotConsumeTime = consumeTime;
    private long ineDailyConsumeTime = consumeTime;
    private long gdNationalConsumeTime = consumeTime;
    private long gdQuarterConsumeTime = consumeTime;
    private long gdSituationConsumeTime = consumeTime;
    private long gdAddConsumeTime = consumeTime;
    private long gdProductionConsumeTime = consumeTime;
    private long gdIndustryConsumeTime = consumeTime;
    private long gdTotalConsumeTime = consumeTime;

    LocalTime start = LocalTime.of(0, 0); // 凌晨 12:00
    LocalTime end = LocalTime.of(7, 0);   // 早上 7:00

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 创建一个多线程的调度器
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(10); // 设定线程池大小，可以根据需要调整
        taskScheduler.initialize();
        taskRegistrar.setTaskScheduler(taskScheduler); // 使用自定义的调度器

        //新浪财经定时录入任务
//        System.out.println("初始化新浪财经定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动新浪财经定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        financeSinaConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.FINANCESINA) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("新浪财经定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    financeSinaConsumeTime = 14400000;//4
                    financeSinaCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(financeSinaCompTime + financeSinaConsumeTime);
                }
        );

        //芝加哥期货交易所定时录入任务
//        System.out.println("初始化芝加哥期货交易所定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动芝加哥期货交易所定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        cbotConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.CBOT) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("芝加哥期货交易所定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    cbotConsumeTime = 14400000;//4
                    cbotCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(cbotCompTime + cbotConsumeTime);
                }
        );

        //上海国际能源交易中心定时录入任务
//        System.out.println("初始化上海国际能源交易中心定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动上海国际能源交易中心定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        ineDailyConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.INEDAILY) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("芝加哥期货交易所定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    ineDailyConsumeTime = 14400000;//4
                    ineDailyCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(ineDailyCompTime + ineDailyConsumeTime);
                }
        );

//        //广东省统计局国民经济主要指标定时录入任务
//        taskRegistrar.addTriggerTask(() -> {
//                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
////                    LocalTime now = LocalTime.now();
////                    if (now.isBefore(start) || now.isAfter(end)) {
//                    gdNationalConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.GD_NATIONAL) + DelayTime;
////                    } else {
////                        // 在 00:00 到 07:00 之间，不执行任务
////                        System.out.println("广东省统计局国民经济主要指标定时任务暂停执行，时间段为 00:00 - 07:00");
////                    }
//                    gdNationalConsumeTime = 14400000;//4
//                    gdNationalCompTime = System.currentTimeMillis();
//                }, triggerContext -> {
//                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
//                    return new Date(gdNationalCompTime + gdNationalConsumeTime);
//                }
//        );

        //广东省统计局季度生产总值定时录入任务
        taskRegistrar.addTriggerTask(() -> {
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                    gdQuarterConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.GD_QUARTER) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("广东省统计局国民经济主要指标定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    gdQuarterConsumeTime = 14400000;//4
                    gdQuarterCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(gdQuarterCompTime + gdQuarterConsumeTime);
                }
        );

        //广东省统计局蔬菜瓜果生产情况定时录入任务
        taskRegistrar.addTriggerTask(() -> {
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                    gdSituationConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.GD_SITUATION) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("广东省统计局蔬菜瓜果生产情况定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    gdSituationConsumeTime = 14400000;//4
                    gdSituationCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(gdSituationCompTime + gdSituationConsumeTime);
                }
        );

        //广东省统计局工业增加值定时录入任务
        taskRegistrar.addTriggerTask(() -> {
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                    gdAddConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.GD_ADD) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("广东省统计局工业增加值定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    gdAddConsumeTime = 14400000;//4
                    gdAddCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(gdAddCompTime + gdAddConsumeTime);
                }
        );

        //广东省统计局主要产品产量定时录入任务
        taskRegistrar.addTriggerTask(() -> {
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                    gdProductionConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.GD_PRODUCTION) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("广东省统计局主要产品产量定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    gdProductionConsumeTime = 14400000;//4
                    gdProductionCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(gdProductionCompTime + gdProductionConsumeTime);
                }
        );

        //广东省统计局工业主要经济指标定时录入任务
        taskRegistrar.addTriggerTask(() -> {
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                    gdIndustryConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.GD_INDUSTRY) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("广东省统计局工业主要经济指标定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    gdIndustryConsumeTime = 14400000;//4
                    gdIndustryCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(gdIndustryCompTime + gdIndustryConsumeTime);
                }
        );

        //广东省统计局社会消费品零售总额定时录入任务
        taskRegistrar.addTriggerTask(() -> {
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                    gdTotalConsumeTime = yqModelAnalysisTaskImpl.enterTask(CrawlerMediaEnum.GD_TOTAL) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("广东省统计局社会消费品零售总额定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    gdTotalConsumeTime = 14400000;//4
                    gdTotalCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(gdTotalCompTime + gdTotalConsumeTime);
                }
        );


    }
}
